export interface Issue {
    id: string;
    name: string;
    descEn: string;
    descCn: string;
    url: string;
}

export const IssueList: Issue[] = [
    {
        id: "ARBITRARY_CODE_EXECUTION_UNDER_LOCK",
        name: "任意代码执行处于锁定状态",
        descEn: "A call which may execute arbitrary code (such as registered, or chained, callbacks) is made while a lock is held. This code may deadlock whenever the callbacks obtain locks themselves, so it is an unsafe pattern. This warning is issued only at the innermost lock acquisition around the final call.",
        descCn: "在保持锁时进行可能执行任意代码（例如已注册或链接的回调）的调用。 每当回调本身获取锁时，此代码可能会死锁，因此这是一种不安全的模式。 此警告仅在最终调用周围的最内层锁获取时发出。",
        url: "https://fbinfer.com/docs/all-issue-types#arbitrary_code_execution_under_lock",
    },
    {
        id: "ASSIGN_POINTER_WARNING",
        name: "分配指针警告",
        descEn: "This check fires when a pointer to an Obj-C object is tagged with an assign property (similar to the -Warc-unsafe-retained-assign compiler flag). Not holding a strong reference to the object makes it easy to accidentally create and use a dangling pointer.",
        descCn: "当指向 Obj-C 对象的指针被标记为属性（类似于编译器标志）时，将触发此检查。不 持有对对象的强引用很容易意外创建 并使用悬空指针。assign-Warc-unsafe-retained-assign",
        url: "https://fbinfer.com/docs/all-issue-types#assign_pointer_warning",
    },
    {
        id: "AUTORELEASEPOOL_SIZE_COMPLEXITY_INCREASE",
        name: "自动释放池大小复杂性增加",
        descEn: "[EXPERIMENTAL] Infer reports this issue when the ObjC autoreleasepool's size complexity of a program increases in degree: e.g. from constant to linear or from logarithmic to quadratic. This issue type is only reported in differential mode: i.e when we are comparing the analysis results of two runs of infer on a file.",
        descCn: "[实验性] 推断在 ObjC 自动发布池的大小复杂性为 程序增加度数：例如从常数到线性或从对数到二次。这 问题类型仅在差异模式下报告：即当我们比较 对一个文件运行两次推理。",
        url: "https://fbinfer.com/docs/all-issue-types#autoreleasepool_size_complexity_increase",
    },
    {
        id: "AUTORELEASEPOOL_SIZE_COMPLEXITY_INCREASE_UI_THREAD",
        name: "自动发布池大小复杂性增加 UI 线程",
        descEn: `[EXPERIMENTAL] Infer reports this issue when the ObjC autoreleasepool's complexity of the procedure increases in degree and the procedure runs on the UI (main) thread.

        Infer considers a method as running on the UI thread whenever:
        
        The method, one of its overrides, its class, or an ancestral class, is annotated with @UiThread.
        The method, or one of its overrides is annotated with @OnEvent, @OnClick, etc.
        The method or its callees call a Litho.ThreadUtils method such as assertMainThread.`,
        descCn: `[实验] 推断报告此问题时 ObjC 自动发布池的复杂性 过程增加程度，过程在 UI（主）线程上运行。
        Infer 认为在以下情况下在 UI 线程上运行的方法：
        
        该方法（其重写之一、其类或祖先类）用 批注。@UiThread
        该方法或其重写之一用 、 等进行批注。@OnEvent@OnClick
        该方法或其被调用方调用诸如 .Litho.ThreadUtilsassertMainThread`,
        url: "https://fbinfer.com/docs/all-issue-types#autoreleasepool_size_complexity_increase_ui_thread",
    },
    {
        id: "AUTORELEASEPOOL_SIZE_UNREACHABLE_AT_EXIT",
        name: "退出时无法到达自动释放池大小",
        descEn: "[EXPERIMENTAL] This issue type indicates that the program's execution doesn't reach the exit node. Hence, we cannot compute a static bound of ObjC autoreleasepool's size for the procedure.",
        descCn: "[实验性] 此问题类型表示程序的执行未到达出口 节点。因此，我们无法计算该过程的 ObjC 自动发布池大小的静态边界。",
        url: "https://fbinfer.com/docs/all-issue-types#autoreleasepool_size_unreachable_at_exit",
    },
    {
        id: "BAD_POINTER_COMPARISON",
        name: "坏指针比较",
        descEn: "Infer reports these warnings in Objective-C when a boxed primitive type such as NSNumber * is coerced to a boolean in a comparison. ",
        descCn: "Infer 在 Objective-C 中报告这些警告时，当盒装基元类型（如）在比较中被强制转换为布尔值时。",
        url: "https://fbinfer.com/docs/all-issue-types#bad_pointer_comparison",
    },
    {
        id: "BIABDUCTION_MEMORY_LEAK",
        name: "内存泄漏",
        descEn: "This error type is only reported in C and Objective-C code. In Java we do not report memory leaks because it is a garbage collected language.",
        descCn: "此错误类型仅在 C 和 Objective-C 代码中报告。在Java中，我们不 报告内存泄漏，因为它是垃圾回收语言。",
        url: "https://fbinfer.com/docs/all-issue-types#biabduction_memory_leak",
    },
    {
        id: "BUFFER_OVERRUN_L1",
        name: "缓冲区溢出 L1",
        descEn: `Buffer overrun reports fall into several "buckets" corresponding to the expected precision of the report. The higher the number, the more likely it is to be a false positive.
        L1: The most faithful report, when it must be unsafe.`,
        descCn: `缓冲区溢出报告分为几个“桶”，对应于 报告。数字越大，误报的可能性就越大。
        L1：最可靠的报告，当它一定不安全的时候。`,
        url: "https://fbinfer.com/docs/all-issue-types#buffer_overrun_l1",
    },
    {
        id: "BUFFER_OVERRUN_L2",
        name: "缓冲区溢出 L2",
        descEn: `Buffer overrun reports fall into several "buckets" corresponding to the expected precision of the report. The higher the number, the more likely it is to be a false positive.
        L2: Less faithful report than L1, when it may be unsafe. `,
        descCn: `缓冲区溢出报告分为几个“桶”，对应于 报告。数字越大，误报的可能性就越大。
        L2：当报告可能不安全时，报告不如L1`,
        url: "https://fbinfer.com/docs/all-issue-types#buffer_overrun_l2",
    },
    {
        id: "BUFFER_OVERRUN_L3",
        name: "缓冲区溢出 L3",
        descEn: `Buffer overrun reports fall into several "buckets" corresponding to the expected precision of the report. The higher the number, the more likely it is to be a false positive.
        L3: The reports that are not included in the above cases.`,
        descCn: `缓冲区溢出报告分为几个“桶”，对应于 报告。数字越大，误报的可能性就越大。
        L3：上述情况中未包含的报告。`,
        url: "https://fbinfer.com/docs/all-issue-types#buffer_overrun_l3",
    },
    {
        id: "BUFFER_OVERRUN_L4",
        name: "缓冲区溢出 L4",
        descEn: `Buffer overrun reports fall into several "buckets" corresponding to the expected precision of the report. The higher the number, the more likely it is to be a false positive.
        L4: More faithful report than L5, when there is an infinity value. `,
        descCn: `缓冲区溢出报告分为几个“桶”，对应于 报告。数字越大，误报的可能性就越大。
        L4：当存在无穷大值时，报告比L5更可靠`,
        url: "https://fbinfer.com/docs/all-issue-types#buffer_overrun_l4",
    },
    {
        id: "BUFFER_OVERRUN_L5",
        name: "缓冲区溢出 L5",
        descEn: `Buffer overrun reports fall into several "buckets" corresponding to the expected precision of the report. The higher the number, the more likely it is to be a false positive.
        L5: The least faithful report, when there is an interval top.`,
        descCn: `缓冲区溢出报告分为几个“桶”，对应于 报告。数字越大，误报的可能性就越大。
        L5：最不可靠的报告`,
        url: "https://fbinfer.com/docs/all-issue-types#buffer_overrun_l5",
    },
    {
        id: "BUFFER_OVERRUN_S2",
        name: "缓冲区溢出 S2",
        descEn: `Buffer overrun reports fall into several "buckets" corresponding to the expected precision of the report. The higher the number, the more likely it is to be a false positive.
        S2: An array access is unsafe by symbolic values. `,
        descCn: `缓冲区溢出报告分为几个“桶”，对应于 报告。数字越大，误报的可能性就越大。
        S2：数组访问因符号值而不安全`,
        url: "https://fbinfer.com/docs/all-issue-types#buffer_overrun_s2",
    },
    {
        id: "BUFFER_OVERRUN_U5",
        name: "缓冲区溢出 U5",
        descEn: `Buffer overrun reports fall into several "buckets" corresponding to the expected precision of the report. The higher the number, the more likely it is to be a false positive.
        U5: An array access is unsafe by unknown values, which are usually from unknown function calls.`,
        descCn: `缓冲区溢出报告分为几个“桶”，对应于 报告。数字越大，误报的可能性就越大。
        U5：未知值对数组访问是不安全的`,
        url: "https://fbinfer.com/docs/all-issue-types#buffer_overrun_u5",
    },
    {
        id: "CAPTURED_STRONG_SELF",
        name: "捕获的强Self",
        descEn: `This will happen in one of two cases generally:

        One uses weakSelf but forgot to declare it weak first.
        One is using strongSelf, declared in a block, in another (inside) block. This changes the delicate balance of the weakSelf/strongSelf use in the first block. The retain cycle is avoided there because strongSelf is a local variable to the block. If strongSelf is used in the inside block, then it's not a local variable anymore, but a captured variable.`,
        descCn: `这通常会在以下两种情况之一中发生：

        一个使用但忘记先声明它是weakSelf
        一种是在另一个（内部）块中使用 ，在块中声明。 这改变了 / 使用的微妙平衡 第一个块。那里避免了保留周期，因为 块的局部变量。如果在内部块中使用， 那么它就不再是局部变量了，而是一个捕获的变量。`,
        url: "https://fbinfer.com/docs/all-issue-types#captured_strong_self",
    },
    {
        id: "CHECKERS_ALLOCATES_MEMORY",
        name: "内存分配检查",
        descEn: "A method annotated with @NoAllocation transitively calls new.",
        descCn: "方法上标记@NoAllocation不能调用new",
        url: "https://fbinfer.com/docs/all-issue-types#checkers_allocates_memory",
    },
    {
        id: "CHECKERS_ANNOTATION_REACHABILITY_ERROR",
        name: "注释可访问性错误",
        descEn: "A method annotated with an annotation @A transitively calls a method annotated @B where the combination of annotations is forbidden (for example, @UiThread calling @WorkerThread).",
        descCn: "用注释@A注释的方法可转换地调用注释@B的方法，其中禁止注释的组合（例如，@UiThread调用@WorkerThread）。",
        url: "https://fbinfer.com/docs/all-issue-types#checkers_annotation_reachability_error",
    },
    {
        id: "CHECKERS_CALLS_EXPENSIVE_METHOD",
        name: "调用的昂贵方法",
        descEn: "A method annotated with @PerformanceCritical transitively calls a method annotated @Expensive.",
        descCn: "用@PerformanceCritical注释的方法可转换地调用用@Expensive注释的方法。",
        url: "https://fbinfer.com/docs/all-issue-types#checkers_calls_expensive_method",
    },
    {
        id: "CHECKERS_EXPENSIVE_OVERRIDES_UNANNOTATED",
        name: "昂贵的未注释覆盖",
        descEn: "A method annotated with @Expensive overrides an un-annotated method.",
        descCn: "批注的方法将覆盖未批注的方法",
        url: "https://fbinfer.com/docs/all-issue-types#checkers_expensive_overrides_unannotated",
    },
    {
        id: "CHECKERS_FRAGMENT_RETAINS_VIEW",
        name: "片段保留视图",
        descEn: "This error type is Android-specific. It fires when a Fragment type fails to nullify one or more of its declared View fields in onDestroyView. In performance-sensitive applications, a Fragment should initialize all View's in onCreateView and nullify them in onDestroyView. If a Fragment is placed on the back stack and fails to nullify a View in onDestroyView, it will retain a useless reference to that View that will not be cleaned up until the Fragment is resumed or destroyed.",
        descCn: "",
        url: "https://fbinfer.com/docs/all-issue-types#checkers_fragment_retains_view",
    },
    {
        id: "CHECKERS_IMMUTABLE_CAST",
        name: "检查不可变转换",
        descEn: "This error type is reported in Java. It fires when an immutable collection is returned from a method whose type is mutable.",
        descCn: "此错误类型在Java中报告。当从类型可变的方法返回不可变的集合时，它会触发。",
        url: "https://fbinfer.com/docs/all-issue-types#checkers_immutable_cast",
    },
    {
        id: "CHECKERS_PRINTF_ARGS",
        name: "检查printf参数",
        descEn: "This error is reported when the argument types to a printf method do not match the format string.",
        descCn: "当方法的参数类型与格式字符串不匹配时，将报告此错误。",
        url: "https://fbinfer.com/docs/all-issue-types#checkers_printf_args",
    },
    {
        id: "COMPONENT_WITH_MULTIPLE_FACTORY_METHODS",
        name: "具有多种工厂方法的组件",
        descEn: `Reported as "Component With Multiple Factory Methods" by linters.`,
        descCn: "具有多种工厂方法的组件",
        url: "https://fbinfer.com/docs/all-issue-types#component_with_multiple_factory_methods",
    },
    {
        id: "CONDITION_ALWAYS_FALSE",
        name: "条件始终为假",
        descEn: "A condition expression is always evaluated to false.",
        descCn: "条件表达式的计算结果始终为 false",
        url: "https://fbinfer.com/docs/all-issue-types#condition_always_false",
    },
    {
        id: "CONDITION_ALWAYS_TRUE",
        name: "条件始终为真",
        descEn: "A condition expression is always evaluated to true.",
        descCn: "条件表达式的计算结果始终为 true。",
        url: "https://fbinfer.com/docs/all-issue-types#condition_always_true",
    },
    {
        id: "CONFIG_CHECKS_BETWEEN_MARKERS",
        name: "标记之间的配置检查",
        descEn: "A config checking is done between a marker's start and end",
        descCn: "在标记的开始和结束之间完成配置检查",
        url: "https://fbinfer.com/docs/all-issue-types#config_checks_between_markers",
    },
    {
        id: "CONFIG_IMPACT",
        name: "配置影响",
        descEn: "A function is called without a config check",
        descCn: "在没有配置检查的情况下调用函数",
        url: "https://fbinfer.com/docs/all-issue-types#config_impact",
    },
    {
        id: "CONSTANT_ADDRESS_DEREFERENCE",
        name: "常量地址解引用",
        descEn: "This is reported when an address obtained via a non-zero constant is dereferenced. If the address is zero then NULLPTR_DEREFERENCE is reported instead.",
        descCn: "当通过非零常数获得的地址被解引用时，会报告这种情况。如果地址为零，则报告NULLPTR_DEREFERENCE。",
        url: "https://fbinfer.com/docs/all-issue-types#constant_address_dereference",
    },
    {
        id: "CREATE_INTENT_FROM_URI",
        name: "从 Uri 创建意图",
        descEn: "Create an intent/start a component using a (possibly user-controlled) URI. may or may not be an issue depending on where the URI comes from.",
        descCn: "使用（可能是用户控制的）URI创建意图/启动组件。根据URI的来源，这可能是一个问题，也可能不是。",
        url: "https://fbinfer.com/docs/all-issue-types#create_intent_from_uri",
    },
    {
        id: "CROSS_SITE_SCRIPTING",
        name: "跨站点脚本",
        descEn: "Untrusted data flows into HTML; XSS risk.",
        descCn: "不受信任的数据流入 HTML;XSS 风险。",
        url: "https://fbinfer.com/docs/all-issue-types#cross_site_scripting",
    },
    {
        id: "CXX_REFERENCE_CAPTURED_IN_OBJC_BLOCK",
        name: "在 Objc 块中捕获的 Cxx 参考",
        descEn: "With this check, Infer detects C++ references captured in a block. Doing this is almost always wrong. The reason is that C++ references are not managed pointers (like ARC pointers) and so the referent is likely to be gone by the time the block gets executed. One solution is to do a local copy of the reference and pass that to the block. ",
        descCn: "通过此检查，Infer可以检测块中捕获的C++引用。这样做几乎总是错误的。原因是C++引用不是托管指针（像ARC指针一样），因此在块执行时，引用可能已经不存在了。一种解决方案是对引用进行本地复制并将其传递给块。",
        url: "https://fbinfer.com/docs/all-issue-types#cxx_reference_captured_in_objc_block",
    },
    {
        id: "DANGLING_POINTER_DEREFERENCE",
        name: "悬空指针解引用",
        descEn: `Reported as "Dangling Pointer Dereference"`,
        descCn: "悬空指针解引用",
        url: "https://fbinfer.com/docs/all-issue-types#dangling_pointer_dereference",
    },
    {
        id: "DEADLOCK",
        name: "死锁",
        descEn: "This error is currently reported in Java. A deadlock occurs when two distinct threads try to acquire two locks in reverse orders. The following code illustrates a textbook example. Of course, in real deadlocks, the lock acquisitions may be separated by deeply nested call chains.",
        descCn: "当前Java中报告了此错误。当两个不同的线程试图以相反的顺序获取两个锁时，就会发生死锁。下面的代码演示了一个教科书示例。当然，在真正的死锁中，锁的获取可能会被深度嵌套的调用链分开。",
        url: "https://fbinfer.com/docs/all-issue-types#deadlock",
    },
    {
        id: "DEAD_STORE",
        name: "未使用变量",
        descEn: "This error is reported in C++. It fires when the value assigned to a variables is never used (e.g., int i = 1; i = 2; return i;).",
        descCn: "C++中报告此错误。当分配给变量的值时触发 从不使用（例如，）。int i = 1; i = 2; return i;",
        url: "https://fbinfer.com/docs/all-issue-types#dead_store",
    },
    {
        id: "DIRECT_ATOMIC_PROPERTY_ACCESS",
        name: "直接原子属性访问",
        descEn: "This check warns you when you are accessing an atomic property directly with an ivar. This makes the atomic property not atomic anymore. So potentially you may get a race condition.",
        descCn: "当您使用ivar直接访问原子属性时，此检查会发出警告。这使得原子性质不再是原子性质。因此，可能会出现数据竞争。",
        url: "https://fbinfer.com/docs/all-issue-types#direct_atomic_property_access",
    },
    {
        id: "DISCOURAGED_WEAK_PROPERTY_CUSTOM_SETTER",
        name: "不鼓励的弱属性自定义setter",
        descEn: "This check warns you when you have a custom setter for a weak property. When compiled with Automatic Reference Counting (ARC, -fobj-arc) ARC may set the property to nil without invoking the setter",
        descCn: "当您有弱属性的自定义setter时，此检查会发出警告。当使用自动参考计数（ARC，-fobj-ARC）编译时，ARC可以在不调用setter的情况下将属性设置为零",
        url: "https://fbinfer.com/docs/all-issue-types#discouraged_weak_property_custom_setter",
    },
    {
        id: "DIVIDE_BY_ZERO",
        name: "除零",
        descEn: `Reported as "Divide By Zero"`,
        descCn: "除零",
        url: "https://fbinfer.com/docs/all-issue-types#divide_by_zero",
    },
    {
        id: "DOTNET_RESOURCE_LEAK",
        name: ".NET 的资源泄漏检查器",
        descEn: `Reported as "Dotnet Resource Leak" `,
        descCn: ".NET 的资源泄漏检查器。",
        url: "https://fbinfer.com/docs/all-issue-types#dotnet_resource_leak",
    },
    {
        id: "EMPTY_VECTOR_ACCESS",
        name: "空集合访问",
        descEn: `This error type is reported only in C++, in versions >= C++11.
        The code is trying to access an element of a vector that Infer believes to be empty. Such an access will cause undefined behavior at runtime.`,
        descCn: `此错误类型仅在C++中报告，版本>=C++11。

        该代码试图访问Infer认为为空的向量的元素。这样的访问将在运行时导致未定义的行为。`,
        url: "https://fbinfer.com/docs/all-issue-types#empty_vector_access",
    },
    {
        id: "ERADICATE_ANNOTATION_GRAPH",
        name: "注释图",
        descEn: `Reported as "Annotation Graph"`,
        descCn: "注释图",
        url: "https://fbinfer.com/docs/all-issue-types#eradicate_annotation_graph",
    },
    {
        id: "ERADICATE_BAD_NESTED_CLASS_ANNOTATION",
        name: "@Nullsafe注释与外部类不一致",
        descEn: `Reported as "@Nullsafe annotation is inconsistent with outer class"`,
        descCn: "@Nullsafe注释与外部类不一致",
        url: "https://fbinfer.com/docs/all-issue-types#eradicate_bad_nested_class_annotation",
    },
    {
        id: "ERADICATE_CONDITION_REDUNDANT",
        name: "条件冗余",
        descEn: "This report is inactive by default. Condition (x != null) or (x == null) when x cannot be null: the first condition is always true and the second is always false",
        descCn: "默认情况下，此报告处于非活动状态。当x不能为null时的条件（x！=null）或（x==null）：第一个条件总是true，第二个条件总是false",
        url: "https://fbinfer.com/docs/all-issue-types#eradicate_condition_redundant",
    },
    {
        id: "ERADICATE_FIELD_NOT_INITIALIZED",
        name: "字段未初始化",
        descEn: "The constructor does not initialize a field f which is not annotated with @Nullable",
        descCn: "构造函数未初始化未使用@Nullable注释的字段f",
        url: "https://fbinfer.com/docs/all-issue-types#eradicate_field_not_initialized",
    },
    {
        id: "ERADICATE_FIELD_NOT_NULLABLE",
        name: "字段不可为空",
        descEn: "An assignment x.f = v where v could be null and field f is not annotated with @Nullable.",
        descCn: "赋值x.f=v，其中v可以为null，字段f不使用@Nullable进行注释。",
        url: "https://fbinfer.com/docs/all-issue-types#eradicate_field_not_nullable",
    },
    {
        id: "ERADICATE_FIELD_OVER_ANNOTATED",
        name: "字段过度注释",
        descEn: `Reported as "Field Over Annotated"`,
        descCn: "字段过度注释",
        url: "https://fbinfer.com/docs/all-issue-types#eradicate_field_over_annotated",
    },
    {
        id: "ERADICATE_INCONSISTENT_SUBCLASS_PARAMETER_ANNOTATION",
        name: "不一致的子类参数注释",
        descEn: "A parameter of the overridden method is missing a @Nullable annotation present in the superclass.",
        descCn: "重写方法的参数缺少超类中存在的@Nullable注释。",
        url: "https://fbinfer.com/docs/all-issue-types#eradicate_inconsistent_subclass_parameter_annotation",
    },
    {
        id: "ERADICATE_INCONSISTENT_SUBCLASS_RETURN_ANNOTATION",
        name: "不一致的子类返回注释",
        descEn: "The return type of the overridden method is annotated @Nullable, but the corresponding method in the superclass is not.",
        descCn: "重写方法的返回类型被注释为@Nullable，但超类中对应的方法不是。",
        url: "https://fbinfer.com/docs/all-issue-types#eradicate_inconsistent_subclass_return_annotation",
    },
    {
        id: "ERADICATE_META_CLASS_CAN_BE_NULLSAFE",
        name: "类有 0 个问题，可以标记为@Nullsafe",
        descEn: `Reported as "Class has 0 issues and can be marked @Nullsafe"`,
        descCn: "类有 0 个问题，可以标记为@Nullsafe",
        url: "https://fbinfer.com/docs/all-issue-types#eradicate_meta_class_can_be_nullsafe",
    },
    {
        id: "ERADICATE_META_CLASS_IS_NULLSAFE",
        name: "类标记为@Nullsafe并且有 0 个问题",
        descEn: `Reported as "Class is marked @Nullsafe and has 0 issues"`,
        descCn: "类标记为@Nullsafe并且有 0 个问题",
        url: "https://fbinfer.com/docs/all-issue-types#eradicate_meta_class_is_nullsafe",
    },
    {
        id: "ERADICATE_META_CLASS_NEEDS_IMPROVEMENT",
        name: "类需要改进才能成为@Nullsafe",
        descEn: `Reported when the class either:
        has at least one nullability issue, or
        has at least one (currently possibly hidden) issue preventing it from being marked @Nullsafe.`,
        descCn: `当班级出现以下情况时报告：
        至少有一个可为Null性问题，或者
        至少有一个（当前可能隐藏）问题使其无法标记为@Nullsafe。`,
        url: "https://fbinfer.com/docs/all-issue-types#eradicate_meta_class_needs_improvement",
    },
    {
        id: "ERADICATE_NULLABLE_DEREFERENCE",
        name: "存在空指针解引用",
        descEn: `Reported as "Nullable Dereference"`,
        descCn: "存在空指针解引用",
        url: "https://fbinfer.com/docs/all-issue-types#eradicate_nullable_dereference",
    },
    {
        id: "ERADICATE_PARAMETER_NOT_NULLABLE",
        name: "参数不可为空",
        descEn: "Method call x.m(..., v, ...) where v can be null and the corresponding parameter in method m is not annotated with @Nullable",
        descCn: "方法调用x.m（…，v，…），其中v可以为null，并且方法m中的相应参数不使用@Nullable进行注释",
        url: "https://fbinfer.com/docs/all-issue-types#eradicate_parameter_not_nullable",
    },
    {
        id: "ERADICATE_REDUNDANT_NESTED_CLASS_ANNOTATION",
        name: "@Nullsafe注释是多余的",
        descEn: `Reported as "@Nullsafe annotation is redundant"`,
        descCn: "@Nullsafe注释是多余的",
        url: "https://fbinfer.com/docs/all-issue-types#eradicate_redundant_nested_class_annotation",
    },
    {
        id: "ERADICATE_RETURN_NOT_NULLABLE",
        name: "返回不能为空",
        descEn: `Method m can return null, but the method's return type is not annotated with @Nullable`,
        descCn: "方法 m 可以返回 null，但该方法的返回类型未批注 @Nullable",
        url: "https://fbinfer.com/docs/all-issue-types#eradicate_return_not_nullable",
    },
    {
        id: "ERADICATE_RETURN_OVER_ANNOTATED",
        name: "返回注释",
        descEn: "This report is inactive by default. Method m is annotated with @Nullable but the method cannot return null",
        descCn: "默认情况下，此报告处于非活动状态。方法 m 用 @Nullable 注释，但 方法不能返回空值",
        url: "https://fbinfer.com/docs/all-issue-types#eradicate_return_over_annotated",
    },
    {
        id: "ERADICATE_UNCHECKED_USAGE_IN_NULLSAFE",
        name: "空安全模式：未经检查的值使用",
        descEn: `Reported as "Nullsafe mode: unchecked usage of a value"`,
        descCn: "空安全模式：未经检查的值使用",
        url: "https://fbinfer.com/docs/all-issue-types#eradicate_unchecked_usage_in_nullsafe",
    },
    {
        id: "ERADICATE_UNVETTED_THIRD_PARTY_IN_NULLSAFE",
        name: "空安全模式：未经审查的第三方的未经检查的使用",
        descEn: `Reported as "Nullsafe mode: unchecked usage of unvetted third-party"`,
        descCn: "空安全模式：未经审查的第三方的未经检查的使用",
        url: "https://fbinfer.com/docs/all-issue-types#eradicate_unvetted_third_party_in_nullsafe",
    },
    {
        id: "EXECUTION_TIME_COMPLEXITY_INCREASE",
        name: "执行时间复杂性增加",
        descEn: "Infer reports this issue when the execution time complexity of a program increases in degree: e.g. from constant to linear or from logarithmic to quadratic. This issue type is only reported in differential mode: i.e when we are comparing the analysis results of two runs of infer on a file.",
        descCn: "推断报告此问题时，执行时间复杂度为 程序增加程度：例如从常数到线性或从 对数到二次。此问题类型仅在 差分模式：即当我们比较 对一个文件运行两次推理。",
        url: "https://fbinfer.com/docs/all-issue-types#execution_time_complexity_increase",
    },
    {
        id: "EXECUTION_TIME_COMPLEXITY_INCREASE_UI_THREAD",
        name: "执行时间复杂性增加 UI 线程",
        descEn: `Infer reports this issue when the execution time complexity of the procedure increases in degree and the procedure runs on the UI (main) thread.
        Infer considers a method as running on the UI thread whenever:
        The method, one of its overrides, its class, or an ancestral class, is annotated with @UiThread.
        The method, or one of its overrides is annotated with @OnEvent, @OnClick, etc.
        The method or its callees call a Litho.ThreadUtils method such as assertMainThread.`,
        descCn: `当过程的执行时间复杂度增加并且过程在UI（主）线程上运行时，Infer会报告此问题。
        无论何时，Infer都会将方法视为在UI线程上运行：
        该方法、它的重写之一、它的类或祖先类都用@UiThread进行了注释。
        该方法或其重写之一用@OnEvent、@OnClick等进行注释。
        该方法或其被调用者调用了Litho.ThreadUtils方法，如assertMainThread。`,
        url: "https://fbinfer.com/docs/all-issue-types#execution_time_complexity_increase_ui_thread",
    },
    {
        id: "EXECUTION_TIME_UNREACHABLE_AT_EXIT",
        name: "退出时无法到达执行",
        descEn: "This issue type indicates that the program's execution doesn't reach the exit node. Hence, we cannot compute a static bound for the procedure.",
        descCn: "此问题类型表示程序的执行未达到 出口节点。因此，我们无法计算 程序。",
        url: "https://fbinfer.com/docs/all-issue-types#execution_time_unreachable_at_exit",
    },
    {
        id: "EXPENSIVE_AUTORELEASEPOOL_SIZE",
        name: "昂贵的自动释放池大小",
        descEn: "[EXPERIMENTAL] This warning indicates that non-constant and non-top ObjC autoreleasepool's size in the procedure. By default, this issue type is disabled.",
        descCn: "[实验]此警告表示手术中ObjC自动释放池的大小为非常量和非顶级。默认情况下，此问题类型处于禁用状态。",
        url: "https://fbinfer.com/docs/all-issue-types#expensive_autoreleasepool_size",
    },
    {
        id: "EXPENSIVE_EXECUTION_TIME",
        name: "昂贵的执行时间",
        descEn: "[EXPERIMENTAL] This warning indicates that non-constant and non-top execution time complexity of the procedure. By default, this issue type is disabled.",
        descCn: "[实验]此警告表示程序的执行时间复杂性为非恒定和非最高。默认情况下，此问题类型处于禁用状态。",
        url: "https://fbinfer.com/docs/all-issue-types#expensive_execution_time",
    },
    {
        id: "EXPENSIVE_LOOP_INVARIANT_CALL",
        name: "昂贵的循环不变调用",
        descEn: "We report this issue type when a function is loop-invariant and also expensive (i.e. at least has linear complexity as determined by the cost analysis).",
        descCn: "当函数是循环不变的并且也是昂贵的（即至少具有由成本分析确定的线性复杂性）时，我们报告了这种问题类型。",
        url: "https://fbinfer.com/docs/all-issue-types#expensive_loop_invariant_call",
    },
    {
        id: "EXPOSED_INSECURE_INTENT_HANDLING",
        name: "暴露的不安全意图处理",
        descEn: `Reported as "Exposed Insecure Intent Handling"`,
        descCn: "暴露的不安全意图处理",
        url: "https://fbinfer.com/docs/all-issue-types#exposed_insecure_intent_handling",
    },
    {
        id: "GLOBAL_VARIABLE_INITIALIZED_WITH_FUNCTION_OR_METHOD_CALL",
        name: "使用函数或方法调用初始化的全局变量",
        descEn: "This checker warns you when the initialization of global variable contain a method or function call. The warning wants to make you aware that some functions are expensive. As the global variables are initialized before main() is called, these initializations can slow down the start-up time of an app.",
        descCn: "当全局变量的初始化包含 方法或函数调用。该警告希望让您意识到某些功能 很贵。由于全局变量在调用 main（） 之前初始化， 这些初始化可能会减慢应用的启动时间。",
        url: "https://fbinfer.com/docs/all-issue-types#global_variable_initialized_with_function_or_method_call",
    },
    {
        id: "GUARDEDBY_VIOLATION",
        name: "违反@GuardedBy",
        descEn: "A field annotated with @GuardedBy is being accessed by a call-chain that starts at a non-private method without synchronization.",
        descCn: "一个以@GuardedBy注释的字段正被一个调用链访问，该调用链在没有同步的情况下从一个非私有方法开始。",
        url: "https://fbinfer.com/docs/all-issue-types#guardedby_violation",
    },
    {
        id: "GUARDEDBY_VIOLATION_NULLSAFE",
        name: "@Nullsafe类中的GuardedBy违规",
        descEn: "A field annotated with @GuardedBy is being accessed by a call-chain that starts at a non-private method without synchronization.",
        descCn: "一个以@GuardedBy注释的字段正被一个调用链访问，该调用链在没有同步的情况下从一个非私有方法开始。",
        url: "https://fbinfer.com/docs/all-issue-types#guardedby_violation_nullsafe",
    },
    {
        id: "IMPURE_FUNCTION",
        name: "非纯函数",
        descEn: "This issue type indicates impure functions. ",
        descCn: "此问题类型表示函数非纯函数",
        url: "https://fbinfer.com/docs/all-issue-types#impure_function",
    },
    {
        id: "INEFFICIENT_KEYSET_ITERATOR",
        name: "低效键集迭代器”",
        descEn: `This issue is raised when
        iterating over a HashMap with ketSet() iterator
        looking up the key each time
        Instead, it is more efficient to iterate over the loop with entrySet which returns key-vaue pairs and gets rid of the hashMap lookup.`,
        descCn: `当
        使用ketSet（）迭代器迭代HashMap
        每次都查钥匙
        相反，使用entrySet在循环上迭代更有效，entrySet返回键-值对并消除hashMap查找。`,
        url: "https://fbinfer.com/docs/all-issue-types#inefficient_keyset_iterator",
    },
    {
        id: "INFERBO_ALLOC_IS_BIG",
        name: "申请过大内存",
        descEn: "malloc is passed a large constant value.",
        descCn: "malloc被传递了一个大的常数值。",
        url: "https://fbinfer.com/docs/all-issue-types#inferbo_alloc_is_big",
    },
    {
        id: "INFERBO_ALLOC_IS_NEGATIVE",
        name: "负数大小的内存申请",
        descEn: "malloc is called with a negative size.",
        descCn: "malloc的调用大小为负数。",
        url: "https://fbinfer.com/docs/all-issue-types#inferbo_alloc_is_negative",
    },
    {
        id: "INFERBO_ALLOC_IS_ZERO",
        name: "申请0空间内存",
        descEn: "malloc is called with a zero size.",
        descCn: "malloc的调用大小为零。",
        url: "https://fbinfer.com/docs/all-issue-types#inferbo_alloc_is_zero",
    },
    {
        id: "INFERBO_ALLOC_MAY_BE_BIG",
        name: "可能申请过大内存",
        descEn: "malloc may be called with a large value.",
        descCn: "malloc可以用一个大值调用。",
        url: "https://fbinfer.com/docs/all-issue-types#inferbo_alloc_may_be_big",
    },
    {
        id: "INFERBO_ALLOC_MAY_BE_NEGATIVE",
        name: "存在负数大小的内存申请",
        descEn: "malloc may be called with a negative value.",
        descCn: "malloc may be called with a negative value.",
        url: "https://fbinfer.com/docs/all-issue-types#inferbo_alloc_may_be_negative",
    },
    {
        id: "INFINITE_AUTORELEASEPOOL_SIZE",
        name: "无限自动释放池大小",
        descEn: "[EXPERIMENTAL] This warning indicates that Infer was not able to determine a static upper bound on the ObjC autoreleasepool's size in the procedure. By default, this issue type is disabled.",
        descCn: "[实验]此警告表明Infer无法在程序中确定ObjC自动释放池大小的静态上限。默认情况下，此问题类型处于禁用状态。",
        url: "https://fbinfer.com/docs/all-issue-types#infinite_autoreleasepool_size",
    },
    {
        id: "INFINITE_EXECUTION_TIME",
        name: "无限执行时间",
        descEn: "This warning indicates that Infer was not able to determine a static upper bound on the execution cost of the procedure. By default, this issue type is disabled.",
        descCn: "此警告表示推断无法确定静态 过程执行成本的上限。默认情况下，这 问题类型已禁用。",
        url: "https://fbinfer.com/docs/all-issue-types#infinite_execution_time",
    },
    {
        id: "INSECURE_INTENT_HANDLING",
        name: "不安全意图处理",
        descEn: `Reported as "Insecure Intent Handling"`,
        descCn: "不安全意图处理",
        url: "https://fbinfer.com/docs/all-issue-types#insecure_intent_handling",
    },
    {
        id: "INTEGER_OVERFLOW_L1",
        name: "整数溢出 L1",
        descEn: `Integer overflows reports fall into several "buckets" corresponding to the expected precision of the report. The higher the number, the more likely it is to be a false positive.
        L1: The most faithful report, when it must be unsafe.`,
        descCn: `整数溢出报告分为几个“桶”，与报告的预期精度相对应。数字越高，假阳性的可能性就越大。
        L1：最可靠的报告，当它一定是不安全的时候。`,
        url: "https://fbinfer.com/docs/all-issue-types#integer_overflow_l1",
    },
    {
        id: "INTEGER_OVERFLOW_L2",
        name: "整数溢出 L2",
        descEn: `Integer overflows reports fall into several "buckets" corresponding to the expected precision of the report. The higher the number, the more likely it is to be a false positive.
        L2: Less faithful report than L1, when it may be unsafe. `,
        descCn: `整数溢出报告分为几个“桶”，与报告的预期精度相对应。数字越高，假阳性的可能性就越大。
        L2：在可能不安全的情况下，报告的可信度低于L1。`,
        url: "https://fbinfer.com/docs/all-issue-types#integer_overflow_l2",
    },
    {
        id: "INTEGER_OVERFLOW_L5",
        name: "整数溢出 L5",
        descEn: `Integer overflows reports fall into several "buckets" corresponding to the expected precision of the report. The higher the number, the more likely it is to be a false positive.
        L5: The reports that are not included in the above cases.`,
        descCn: `整数溢出报告分为几个“桶”，与报告的预期精度相对应。数字越高，假阳性的可能性就越大。
        L5：上述案例中未包含的报告。`,
        url: "https://fbinfer.com/docs/all-issue-types#integer_overflow_l5",
    },
    {
        id: "INTEGER_OVERFLOW_U5",
        name: "整数溢出 U5",
        descEn: `Integer overflows reports fall into several "buckets" corresponding to the expected precision of the report. The higher the number, the more likely it is to be a false positive.
        U5: A binary integer operation is unsafe by unknown values, which are usually from unknown function calls.`,
        descCn: `整数溢出报告分为几个“桶”，与报告的预期精度相对应。数字越高，假阳性的可能性就越大。
        U5：二进制整数运算由于未知值而不安全，这些值通常来自未知函数调用。`,
        url: "https://fbinfer.com/docs/all-issue-types#integer_overflow_u5",
    },
    {
        id: "INTERFACE_NOT_THREAD_SAFE",
        name: "接口线程不安全",
        descEn: "This error indicates that you have invoked an interface method not annotated with @ThreadSafe from a thread-safe context (e.g., code that uses locks or is marked @ThreadSafe). The fix is to add the @ThreadSafe annotation to the interface or to the interface method. For background on why these annotations are needed, see the detailed explanation here.",
        descCn: "此错误表示您已从线程安全上下文调用了一个未用@ThreadSafe注释的接口方法（例如，使用锁或标记为@ThreadSafe的代码）。修复方法是将@ThreadSafe注释添加到接口或接口方法中。有关为什么需要这些注释的背景信息，请参阅此处的详细解释。",
        url: "https://fbinfer.com/docs/all-issue-types#interface_not_thread_safe",
    },
    {
        id: "INVARIANT_CALL",
        name: "不变调用",
        descEn: `We report this issue type when a function call is loop-invariant and hoistable, i.e.
        the function has no side side effects (pure)
        has invariant arguments and result (i.e. have the same value in all loop iterations)
        it is guaranteed to execute, i.e. it dominates all loop sources`,
        descCn: `当函数调用是循环不变和可提升的时，我们报告了这种问题类型，即。
        该功能没有副作用（纯）
        具有不变的参数和结果（即在所有循环迭代中具有相同的值）
        它保证执行，即它控制所有循环源`,
        url: "https://fbinfer.com/docs/all-issue-types#invariant_call",
    },
    {
        id: "IPC_ON_UI_THREAD",
        name: "Ui线程上的Ipc",
        descEn: "A blocking Binder IPC call occurs on the UI thread.",
        descCn: "UI线程上发生阻塞Binder IPC调用。",
        url: "https://fbinfer.com/docs/all-issue-types#ipc_on_ui_thread",
    },
    {
        id: "IVAR_NOT_NULL_CHECKED",
        name: "ivar缺乏空检查",
        descEn: "This error type is only reported in Objective-C. This is similar to Null dereference, but Infer hasn't found a whole trace where the error can happen, but only found that a null dereference can happen if an instance variable of a parameter is nil.",
        descCn: "此错误类型仅在Objective-C中报告。这类似于Null解引用，但Infer没有找到可能发生错误的整个跟踪，但只发现如果参数的实例变量为nil，则可能发生Null解引用",
        url: "https://fbinfer.com/docs/all-issue-types#ivar_not_null_checked",
    },
    {
        id: "JAVASCRIPT_INJECTION",
        name: "javascript注入",
        descEn: "Untrusted data flows into JavaScript.",
        descCn: "不受信任的数据流入JavaScript。",
        url: "https://fbinfer.com/docs/all-issue-types#javascript_injection",
    },
    {
        id: "LOCKLESS_VIOLATION",
        name: "无锁违规",
        descEn: "A method implements an interface signature annotated with @Lockless but which transitively acquires a lock.",
        descCn: "一个方法实现了一个用@Lockless注释的接口签名，但它可以传递地获取一个锁。",
        url: "https://fbinfer.com/docs/all-issue-types#lockless_violation",
    },
    {
        id: "LOCK_CONSISTENCY_VIOLATION",
        name: "锁一致性违规",
        descEn: `This is an error reported on C++ and Objective C classes whenever:
        Some class method directly uses locking primitives (not transitively).
        It has a public method which writes to some member x while holding a lock.
        It has a public method which reads x without holding a lock.`,
        descCn: `这是在C++和Objective C类上报告的错误，只要：
        有些类方法直接使用锁定基元（而不是传递性的）。
        它有一个公共方法，在持有锁的同时写入某个成员x。
        它有一个公共方法，可以在不持有锁的情况下读取x。`,
        url: "https://fbinfer.com/docs/all-issue-types#lock_consistency_violation",
    },
    {
        id: "LOGGING_PRIVATE_DATA",
        name: "记录隐私数据",
        descEn: `Reported as "Logging Private Data"`,
        descCn: "记录隐私数据",
        url: "https://fbinfer.com/docs/all-issue-types#logging_private_data",
    },
    {
        id: "MEMORY_LEAK",
        name: "内存泄漏",
        descEn: `Reported as "Memory Leak"`,
        descCn: "内存泄漏",
        url: "https://fbinfer.com/docs/all-issue-types#memory_leak",
    },
    {
        id: "MISSING_REQUIRED_PROP",
        name: "缺少必要属性",
        descEn: `Reported as "Missing Required Prop"`,
        descCn: "缺少必要属性",
        url: "https://fbinfer.com/docs/all-issue-types#missing_required_prop",
    },
    {
        id: "MIXED_SELF_WEAKSELF",
        name: "混合使用self和weakSelf",
        descEn: "This happens when an Objective-C block captures both self and weakSelf, a weak pointer to self. Possibly the developer meant to capture only weakSelf to avoid a retain cycle, but made a typo and used self as well in the block, instead of strongSelf. In this case, this could cause a retain cycle.",
        descCn: "当Objective-C块同时捕获self和weakSelf（指向self的弱指针）时，就会发生这种情况。开发人员可能只想捕获weakSelf以避免保留周期，但犯了一个拼写错误，并在块中使用了self，而不是strong self。在这种情况下，这可能会导致一个保留周期。",
        url: "https://fbinfer.com/docs/all-issue-types#mixed_self_weakself",
    },
    {
        id: "MODIFIES_IMMUTABLE",
        name: "修改不可变值",
        descEn: "This issue type indicates modifications to fields marked as @Immutable. ",
        descCn: "此问题类型表示对标记为@Immutable的字段的修改。",
        url: "https://fbinfer.com/docs/all-issue-types#modifies_immutable",
    },
    {
        id: "MULTIPLE_WEAKSELF",
        name: "多个weakSelf",
        descEn: "An Objective-C block uses weakSelf more than once. This could lead to unexpected behaviour. Even if weakSelf is not nil in the first use, it could be nil in the following uses since the object that weakSelf points to could be freed anytime. One should assign it to a strong pointer first, and then use it in the block.",
        descCn: "Objective-C块多次使用weakSelf。这可能会导致意想不到的行为。即使weakSelf在第一次使用中不是nil，但在接下来的使用中也可能是nil，因为weakSelf指向的对象可以随时释放。应该先将它分配给一个强指针，然后在块中使用它。",
        url: "https://fbinfer.com/docs/all-issue-types#multiple_weakself",
    },
    {
        id: "MUTABLE_LOCAL_VARIABLE_IN_COMPONENT_FILE",
        name: "组件文件中的可变本地变量",
        descEn: `Reported as "Mutable Local Variable In Component File"`,
        descCn: "组件文件中的可变本地变量",
        url: "https://fbinfer.com/docs/all-issue-types#mutable_local_variable_in_component_file",
    },
    {
        id: "NIL_MESSAGING_TO_NON_POD",
        name: "向非Pod发送空消息",
        descEn: `Reported as "Nil Messaging To Non Pod"`,
        descCn: "向非Pod发送空消息",
        url: "https://fbinfer.com/docs/all-issue-types#nil_messaging_to_non_pod",
    },
    {
        id: "NULLPTR_DEREFERENCE",
        name: "空指针解引用",
        descEn: "Infer reports null dereference bugs in Java, C, C++, and Objective-C when it is possible that the null pointer is dereferenced, leading to a crash.",
        descCn: "Infer报告Java、C、C++和Objective-C中的null解引用错误，因为null指针可能被解引用，从而导致崩溃。",
        url: "https://fbinfer.com/docs/all-issue-types#nullptr_dereference",
    },
    {
        id: "NULL_DEREFERENCE",
        name: "空指针解引用",
        descEn: `Reported as "Null Dereference"`,
        descCn: "空指针解引用",
        url: "https://fbinfer.com/docs/all-issue-types#null_dereference",
    },
    {
        id: "OPTIONAL_EMPTY_ACCESS",
        name: "可选空访问",
        descEn: "Optional Empty Access warnings are reported when we try to retrieve the value of a folly::Optional when it is empty (i.e. folly::none).",
        descCn: "当我们试图检索folly::Optional时，会报告可选的空访问警告，当它为空时（即folly::Optional）。",
        url: "https://fbinfer.com/docs/all-issue-types#optional_empty_access",
    },
    {
        id: "PARAMETER_NOT_NULL_CHECKED",
        name: "参数未检查为空",
        descEn: "This error type is reported only in Objective-C. It is similar to Null dereference, but Infer hasn't found a whole trace where the error can happen, but only found that a null dereference can happen if you call a method with nil as an argument. Therefore it is only a warning. ",
        descCn: "此错误类型仅在Objective-C中报告。它类似于Null解引用，但Infer没有找到可能发生错误的整个跟踪，但只发现如果调用以nil为参数的方法，则可能发生Null解引用。因此，这只是一个警告。",
        url: "https://fbinfer.com/docs/all-issue-types#parameter_not_null_checked",
    },
    {
        id: "POINTER_TO_CONST_OBJC_CLASS",
        name: "指向Const Objc类的指针",
        descEn: "In Objective-C, const Class * represents a mutable pointer pointing to an Objective-C class where the ivars cannot be changed. More useful is Class *const instead, meaning the destination of the pointer cannot be changed.",
        descCn: "在Objective-C中，const Class*表示一个可变指针，指向一个不能更改ivar的Objective-C类。更有用的是Class*const，这意味着指针的目的地不能更改。",
        url: "https://fbinfer.com/docs/all-issue-types#pointer_to_const_objc_class",
    },
    {
        id: "PREMATURE_NIL_TERMINATION_ARGUMENT",
        name: "缺失的零结尾参数",
        descEn: "This error type is reported in C and Objective-C. In many variadic methods, nil is used to signify the end of the list of input objects. This is similar to nil-termination of C strings. If one of the arguments that is not the last argument to the method is nil as well, Infer reports an error because that may lead to unexpected behavior.",
        descCn: "此错误类型在C和Objective-C中报告。在许多可变方法中，nil用于表示输入对象列表的末尾。这类似于C字符串的零终止。如果不是该方法最后一个参数的参数之一也是nil，则Infer会报告错误，因为这可能会导致意外行为。",
        url: "https://fbinfer.com/docs/all-issue-types#premature_nil_termination_argument",
    },
    {
        id: "PULSE_UNINITIALIZED_VALUE",
        name: "未初始化值",
        descEn: `Reported as "Uninitialized Value"`,
        descCn: "未初始化值",
        url: "https://fbinfer.com/docs/all-issue-types#pulse_uninitialized_value",
    },
    {
        id: "PURE_FUNCTION",
        name: "纯功能",
        descEn: "This issue type indicates pure functions.",
        descCn: "此问题类型表示纯函数。",
        url: "https://fbinfer.com/docs/all-issue-types#pure_function",
    },
    {
        id: "QUANDARY_TAINT_ERROR",
        name: "污染错误",
        descEn: "Generic taint error when nothing else fits.",
        descCn: "没有其他适合的情况下出现一般污染错误。",
        url: "https://fbinfer.com/docs/all-issue-types#quandary_taint_error",
    },
    {
        id: "RESOURCE_LEAK",
        name: "资源泄漏",
        descEn: "Infer reports resource leaks in C, Objective-C and Java. In general, resources are entities such as files, sockets, connections, etc, that need to be closed after being used.",
        descCn: "Infer报告了C、Objective-C和Java中的资源泄漏。通常，资源是文件、套接字、连接等实体，在使用后需要关闭。",
        url: "https://fbinfer.com/docs/all-issue-types#resource_leak",
    },
    {
        id: "RETAIN_CYCLE",
        name: "循环获取",
        descEn: "A retain cycle is a situation when object A retains object B, and object B retains object A at the same time.",
        descCn: "保留周期是指对象A获取对象B，而对象B同时获取对象A的情况。",
        url: "https://fbinfer.com/docs/all-issue-types#retain_cycle",
    },
    {
        id: "SHELL_INJECTION",
        name: "shell注入",
        descEn: "Environment variable or file data flowing to shell.",
        descCn: "流向shell的环境变量或文件数据",
        url: "https://fbinfer.com/docs/all-issue-types#shell_injection",
    },
    {
        id: "SHELL_INJECTION_RISK",
        name: "shell注入风险",
        descEn: "Code injection if the caller of the endpoint doesn't sanitize on its end.",
        descCn: "如果端点的调用方没有在其端部进行清理，则进行代码注入。",
        url: "https://fbinfer.com/docs/all-issue-types#shell_injection_risk",
    },
    {
        id: "SQL_INJECTION",
        name: "sql注入",
        descEn: "Untrusted and unescaped data flows to SQL.",
        descCn: "不受信任和未转义的数据流向SQL",
        url: "https://fbinfer.com/docs/all-issue-types#sql_injection",
    },
    {
        id: "SQL_INJECTION_RISK",
        name: "sql注入风险",
        descEn: "Untrusted and unescaped data flows to SQL.",
        descCn: "不受信任和未转义的数据流向SQL",
        url: "https://fbinfer.com/docs/all-issue-types#sql_injection_risk",
    },
    {
        id: "STACK_VARIABLE_ADDRESS_ESCAPE",
        name: "无效栈地址",
        descEn: "Reported when an address pointing into the stack of the current function will escape to its calling context. Such addresses will become invalid by the time the function actually returns so are potentially dangerous.",
        descCn: "当指向当前函数堆栈的地址将转义到其调用上下文时报告。当函数实际返回时，这些地址将变得无效，因此具有潜在的危险性。",
        url: "https://fbinfer.com/docs/all-issue-types#stack_variable_address_escape",
    },
    {
        id: "STARVATION",
        name: "程序僵死",
        descEn: "This error is reported in Java, and specifically on Android. These reports are triggered when a method that runs on the UI thread may block, thus potentially leading to an Application Not Responding error.",
        descCn: "此错误在Java中报告，特别是在Android上。当在UI线程上运行的方法可能会阻塞，从而可能导致应用程序未响应错误时，会触发这些报告。",
        url: "https://fbinfer.com/docs/all-issue-types#starvation",
    },
    {
        id: "STATIC_INITIALIZATION_ORDER_FIASCO",
        name: "静态初始化顺序失效",
        descEn: "This error is reported in C++. It fires when the initialization of a static variable A, accesses a static variable B from another translation unit (usually another .cpp file). There are no guarantees whether B has been already initialized or not at that point.",
        descCn: "此错误在C++中报告。当静态变量a的初始化从另一个转换单元（通常是另一个.cpp文件）访问静态变量B时，它会触发。在这一点上，无法保证B是否已经初始化。",
        url: "https://fbinfer.com/docs/all-issue-types#static_initialization_order_fiasco",
    },
    {
        id: "STRICT_MODE_VIOLATION",
        name: "违反严格模式",
        descEn: "Android has a feature called strict mode, which if enabled, will flag the occasions where the main thread makes a call that results in disk I/O, waiting on a network socket, etc. The analysis catching starvation errors and deadlocks (the --starvation analysis) has the ability to statically detect such violations.",
        descCn: "Android有一个称为严格模式的功能，如果启用该功能，将标记主线程进行调用导致磁盘I/O、等待网络套接字等的情况。捕捉饥饿错误和死锁的分析（饥饿分析）能够静态检测此类违规行为。",
        url: "https://fbinfer.com/docs/all-issue-types#strict_mode_violation",
    },
    {
        id: "STRONG_DELEGATE_WARNING",
        name: "强代理警告",
        descEn: "This check warns you when you have a property called delegate or variations thereof which is declared strong. The idea is that delegates should generally be weak, otherwise this may cause retain cycles.",
        descCn: "当您有一个名为delegate的属性或其变体被声明为强时，此检查会发出警告。其想法是，代理通常应该很弱，否则可能会导致保留周期。",
        url: "https://fbinfer.com/docs/all-issue-types#strong_delegate_warning",
    },
    {
        id: "STRONG_SELF_NOT_CHECKED",
        name: "strongSelf未检查",
        descEn: `Reported as "StrongSelf Not Checked"`,
        descCn: "strongSelf未检查",
        url: "https://fbinfer.com/docs/all-issue-types#strong_self_not_checked",
    },
    {
        id: "THREAD_SAFETY_VIOLATION",
        name: "违反线程安全",
        descEn: "This warning indicates a potential data race in Java. The analyser is called RacerD and this section gives brief but a mostly complete description of its features. ",
        descCn: "此警告表示Java中存在潜在的数据竞争。分析仪被称为RacerD，本节对其功能进行了简要但基本完整的描述。",
        url: "https://fbinfer.com/docs/all-issue-types#thread_safety_violation",
    },
    {
        id: "THREAD_SAFETY_VIOLATION_NULLSAFE",
        name: "@Nullsafe类线程安全冲突",
        descEn: "A Thread Safety Violation in a @Nullsafe class.",
        descCn: "@Nullsafe类中的线程安全冲突。",
        url: "https://fbinfer.com/docs/all-issue-types#thread_safety_violation_nullsafe",
    },
    {
        id: "TOPL_ERROR",
        name: "违反Topl属性",
        descEn: "A violation of a Topl property (user-specified).",
        descCn: "违反Topl属性（用户指定）。",
        url: "https://fbinfer.com/docs/all-issue-types#topl_error",
    },
    {
        id: "UNINITIALIZED_VALUE",
        name: "未初始化的值",
        descEn: "A value is read before it has been initialized. ",
        descCn: "值在初始化之前被读取。",
        url: "https://fbinfer.com/docs/all-issue-types#uninitialized_value",
    },
    {
        id: "UNREACHABLE_CODE",
        name: "无法访问的代码",
        descEn: "A program point is unreachable.",
        descCn: "无法访问的代码",
        url: "https://fbinfer.com/docs/all-issue-types#unreachable_code",
    },
    {
        id: "UNTRUSTED_BUFFER_ACCESS",
        name: "不受信任的缓冲区访问",
        descEn: "Untrusted data of any kind flowing to buffer.",
        descCn: "流向缓冲区的任何类型的不受信任的数据。",
        url: "https://fbinfer.com/docs/all-issue-types#untrusted_buffer_access",
    },
    {
        id: "UNTRUSTED_DESERIALIZATION",
        name: "不受信任的反序列化",
        descEn: "User-controlled deserialization.",
        descCn: "用户控制的反序列化。",
        url: "https://fbinfer.com/docs/all-issue-types#untrusted_deserialization",
    },
    {
        id: "UNTRUSTED_DESERIALIZATION_RISK",
        name: "不受信任的反序列化风险",
        descEn: "User-controlled deserialization",
        descCn: "用户控制的反序列化。",
        url: "https://fbinfer.com/docs/all-issue-types#untrusted_deserialization_risk",
    },
    {
        id: "UNTRUSTED_ENVIRONMENT_CHANGE_RISK",
        name: "不受信任的环境更改风险",
        descEn: "User-controlled environment mutation.",
        descCn: "用户控制的环境突变。",
        url: "https://fbinfer.com/docs/all-issue-types#untrusted_environment_change_risk",
    },
    {
        id: "UNTRUSTED_FILE",
        name: "不受信任的文件",
        descEn: "User-controlled file creation; may be vulnerable to path traversal and more.",
        descCn: "用户控制的文件创建;可能容易受到路径遍历等的影响",
        url: "https://fbinfer.com/docs/all-issue-types#untrusted_file",
    },
    {
        id: "UNTRUSTED_FILE_RISK",
        name: "不受信任的文件风险",
        descEn: "User-controlled file creation; may be vulnerable to path traversal and more.",
        descCn: "用户控制的文件创建;可能容易受到路径遍历等的影响",
        url: "https://fbinfer.com/docs/all-issue-types#untrusted_file_risk",
    },
    {
        id: "UNTRUSTED_HEAP_ALLOCATION",
        name: "不受信任的堆分配",
        descEn: "Untrusted data of any kind flowing to heap allocation. this can cause crashes or DOS.",
        descCn: "流向堆分配的任何类型的不受信任的数据。这可能会导致崩溃或拒绝服务。",
        url: "https://fbinfer.com/docs/all-issue-types#untrusted_heap_allocation",
    },
    {
        id: "UNTRUSTED_INTENT_CREATION",
        name: "不受信任的意图创建",
        descEn: "Creating an Intent from user-controlled data.",
        descCn: "从用户控制的数据创建意向。",
        url: "https://fbinfer.com/docs/all-issue-types#untrusted_intent_creation",
    },
    {
        id: "UNTRUSTED_URL_RISK",
        name: "不受信任的 URL 风险",
        descEn: "Untrusted flag, environment variable, or file data flowing to URL.",
        descCn: "不受信任的标志、环境变量或流向 URL 的文件数据。",
        url: "https://fbinfer.com/docs/all-issue-types/#untrusted_url_risk",
    },
    {
        id: "UNTRUSTED_VARIABLE_LENGTH_ARRAY",
        name: "不受信任的可变长度数组",
        descEn: "Untrusted data of any kind flowing to stack buffer allocation. Trying to allocate a stack buffer that's too large will cause a stack overflow.",
        descCn: "流向堆栈缓冲区分配的任何类型的不受信任数据。尝试分配太大的堆栈缓冲区将导致堆栈溢出。",
        url: "https://fbinfer.com/docs/all-issue-types/#untrusted_variable_length_array",
    },
    {
        id: "USER_CONTROLLED_SQL_RISK",
        name: "用户控制的 SQL 风险",
        descEn: "Untrusted data flows to SQL (no injection risk).",
        descCn: "不受信任的数据流向 SQL（无注入风险）",
        url: "https://fbinfer.com/docs/all-issue-types/#user_controlled_sql_risk",
    },
    {
        id: "USE_AFTER_DELETE",
        name: "删除后使用",
        descEn: "An address that was invalidated by a call to delete in C++ is dereferenced.",
        descCn: "一个被C++中的删除调用所无效的地址被使用。",
        url: "https://fbinfer.com/docs/all-issue-types/#use_after_delete",
    },
    {
        id: "USE_AFTER_FREE",
        name: "释放后使用",
        descEn: "An address that was invalidated by a call to free in C is dereferenced.",
        descCn: "在C中被调用free而无效的地址被使用。",
        url: "https://fbinfer.com/docs/all-issue-types/#use_after_free",
    },
    {
        id: "USE_AFTER_LIFETIME",
        name: "使用过期地址",
        descEn: "The lifetime of an object has ended but that object is being accessed. ",
        descCn: "对象的生存期已结束，但正在访问该对象。",
        url: "https://fbinfer.com/docs/all-issue-types/#use_after_lifetime",
    },
    {
        id: "VECTOR_INVALIDATION",
        name: "向量地址无效",
        descEn: "An address pointing into a C++ std::vector might have become invalid. This can happen when an address is taken into a vector, then the vector is mutated in a way that might invalidate the address, for example by adding elements to the vector, which might trigger a re-allocation of the entire vector contents (thereby invalidating the pointers into the previous location of the contents).",
        descCn: "指向C++ std::vector的地址可能已无效。当一个地址被放入一个向量中，然后该向量以可能使地址无效的方式发生突变时，就会发生这种情况，例如，通过向向量中添加元素，这可能会触发整个向量内容的重新分配（从而使指向内容的前一位置的指针无效）。",
        url: "https://fbinfer.com/docs/all-issue-types/#vector_invalidation",
    },
    {
        id: "WEAK_SELF_IN_NO_ESCAPE_BLOCK",
        name: "weakSelf中非Escape块",
        descEn: "In many methods that take a block as an argument, the block position is annotated with NS_NOESCAPE to mark that the block passed to this method won't be leaving the current scope. In those cases, there is no need to use weakSelf to avoid the block to capture self. This issue type flags this case.",
        descCn: "在许多以块为参数的方法中，块位置用NS_NOESCAPE进行注释，以标记传递给该方法的块不会离开当前范围。在这些情况下，没有必要使用weakSelf来避免阻止捕获self。此问题类型标记此情况。",
        url: "https://fbinfer.com/docs/all-issue-types/#weak_self_in_no_escape_block",
    },
];